home *** CD-ROM | disk | FTP | other *** search
/ Aminet 41 / Aminet 41 (2001)(Schatztruhe)[!][Feb 2001].iso / Aminet / comm / misc / MPackMUI.lha / MPackMUI / Source / ProgFuncs.C < prev    next >
C/C++ Source or Header  |  2000-08-23  |  5KB  |  258 lines
  1. // --------------------------------------------------------------------------------------------------------------
  2. //
  3. //   MPackMUI V1.01 Program Module
  4. //
  5. // --------------------------------------------------------------------------------------------------------------
  6.  
  7. #include "ProgFuncs.h"
  8.  
  9. // --------------------------------------------------------------------------------------------------------------
  10.  
  11. void FreeList(struct List *list)
  12. {
  13.     struct Node *tempnode, *nextnode;
  14.  
  15.     // Frees all the nodes and their names in a given list
  16.  
  17.     if (!(IsListEmpty(list)))
  18.     {
  19.         tempnode = list->lh_Head;
  20.  
  21.         while (tempnode->ln_Succ)
  22.         {
  23.             nextnode = tempnode->ln_Succ;
  24.  
  25.             FreeMem(tempnode->ln_Name, 256);
  26.             FreeMem(tempnode, sizeof(struct Node));
  27.  
  28.             tempnode = nextnode;
  29.         } /* while */
  30.     } /* if */
  31. } /* FreeList() */
  32.  
  33. // --------------------------------------------------------------------------------------------------------------
  34.  
  35. void DefaultMIMEList()
  36. {
  37.     UBYTE loop;
  38.     struct Node *tempnode;
  39.  
  40.     // Initialise the MIME types list with default values
  41.  
  42.     NewList(&MIMEList);
  43.  
  44.     loop = 0;
  45.  
  46.     while(DefaultMIMETypes[loop] != NULL)
  47.     {
  48.         if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  49.         {
  50.             DoEasyReq("Couldn't allocate node");
  51.             CleanUp();
  52.         } /* if */
  53.  
  54.         if (!(tempnode->ln_Name = AllocMem(256, 0)))
  55.         {
  56.             DoEasyReq("Couldn't allocate label");
  57.             CleanUp();
  58.         } /* if */
  59.  
  60.         strcpy(tempnode->ln_Name, DefaultMIMETypes[loop]);
  61.  
  62.         AddTail(&MIMEList, tempnode);
  63.  
  64.         loop++;
  65.     } /* while */
  66.  
  67.     // Rebuild the MIME types array from the MIME types list
  68.  
  69.     RebuildMIMETypes();
  70. } /* DefaultMIMEList() */
  71.  
  72. // --------------------------------------------------------------------------------------------------------------
  73.  
  74. void RebuildMIMETypes()
  75. {
  76.     UWORD loop;
  77.     struct Node *tempnode;
  78.  
  79.     // Rebuild the MIME types array from the MIME types list
  80.  
  81.     // Free old array
  82.  
  83.     loop = 0;
  84.  
  85.     while (MIMETypes[loop])
  86.     {
  87.         FreeMem(MIMETypes[loop], 256);
  88.  
  89.         loop++;
  90.     } /* while */
  91.  
  92.     // Build new array
  93.  
  94.     loop = 0;
  95.  
  96.     if (!(IsListEmpty(&MIMEList)))
  97.     {
  98.         tempnode = MIMEList.lh_Head;
  99.  
  100.         while (tempnode->ln_Succ)
  101.         {
  102.             if (!(MIMETypes[loop] = AllocMem(256, 0)))
  103.             {
  104.                 DoEasyReq("Couldn't allocate label");
  105.                 CleanUp();
  106.             } /* if */
  107.  
  108.             strcpy(MIMETypes[loop], tempnode->ln_Name);
  109.  
  110.             loop++;
  111.             tempnode = tempnode->ln_Succ;
  112.         } /* while */
  113.     } /* if */
  114.  
  115.     MIMETypes[loop] = NULL;
  116. } /* RebuildMIMETypes() */
  117.  
  118. // --------------------------------------------------------------------------------------------------------------
  119.  
  120. void RebuildMIMEList()
  121. {
  122.     struct Node *tempnode;
  123.     UWORD loop;
  124.  
  125.     // Rebuild the MIME types list from the MIME types array
  126.  
  127.     // Free old list
  128.  
  129.     FreeList(&MIMEList);
  130.  
  131.     // Build new list
  132.  
  133.     NewList(&MIMEList);
  134.  
  135.     loop = 0;
  136.  
  137.     while (MIMETypes[loop])
  138.     {
  139.         // Create a new node
  140.  
  141.         if (!(tempnode = AllocMem(sizeof(struct Node), 0)))
  142.         {
  143.             DoEasyReq("Couldn't allocate node");
  144.             CleanUp();
  145.         } /* if */
  146.  
  147.         if (!(tempnode->ln_Name = AllocMem(256, 0)))
  148.         {
  149.             DoEasyReq("Couldn't allocate label");
  150.             CleanUp();
  151.         } /* if */
  152.  
  153.         strcpy(tempnode->ln_Name, MIMETypes[loop]);
  154.  
  155.         AddTail(&MIMEList, tempnode);
  156.  
  157.         loop++;
  158.     } /* while */
  159. } /* RebuildMIMEList() */
  160.  
  161. // --------------------------------------------------------------------------------------------------------------
  162.  
  163. void OpenPrefs(char *filename)
  164. {
  165.     BPTR prefsfile;
  166.     char buffer[256];
  167.     UWORD loop;
  168.  
  169.     // Open MIME types file
  170.  
  171.     if (!(prefsfile = Open(filename, MODE_OLDFILE)))
  172.     {
  173.         // No prefs file. Use defaults
  174.  
  175.         DefaultMIMEList();
  176.  
  177.         return;
  178.     } /* if */
  179.  
  180.     // Free old array
  181.  
  182.     loop = 0;
  183.  
  184.     while (MIMETypes[loop])
  185.     {
  186.         FreeMem(MIMETypes[loop], 256);
  187.  
  188.         loop++;
  189.     } /* while */
  190.  
  191.     // Build new array
  192.  
  193.     loop = 0;
  194.  
  195.     while (FGets(prefsfile, buffer, 256))
  196.     {
  197.         // Add an entry to the array
  198.  
  199.         if (!(MIMETypes[loop] = AllocMem(256, 0)))
  200.         {
  201.             DoEasyReq("Couldn't allocate label");
  202.             CleanUp();
  203.         } /* if */
  204.  
  205.         // Remove newline
  206.  
  207.         buffer[strlen(buffer) - 1] = '\0';
  208.  
  209.         strcpy(MIMETypes[loop], buffer);
  210.  
  211.         loop++;
  212.     } /* while */
  213.  
  214.     Close(prefsfile);
  215.  
  216.     MIMETypes[loop] = NULL;
  217.  
  218.     // Rebuild the MIME types list from the MIME types array
  219.  
  220.     NewList(&MIMEList);
  221.  
  222.     RebuildMIMEList();
  223.  
  224.     return;
  225. } /* OpenPrefs() */
  226.  
  227. // --------------------------------------------------------------------------------------------------------------
  228.  
  229. void SavePrefs(char *filename)
  230. {
  231.     BPTR prefsfile;
  232.     UWORD loop;
  233.  
  234.     // Save MIME types to a file
  235.  
  236.     if (!(prefsfile = Open(filename, MODE_NEWFILE)))
  237.     {
  238.         DoEasyReq("Could't save prefs");
  239.         return;
  240.     } /* if */
  241.  
  242.     loop = 0;
  243.  
  244.     while (MIMETypes[loop])
  245.     {
  246.         FPuts(prefsfile, MIMETypes[loop]);
  247.         FPutC(prefsfile, '\n');
  248.  
  249.         loop++;
  250.     } /* while */
  251.  
  252.     Close(prefsfile);
  253. } /* SavePrefs() */
  254.  
  255. // --------------------------------------------------------------------------------------------------------------
  256.  
  257. // End Of Text
  258.